export const publicMethodList = [
    {
        name: '前端模糊查询方法',

        html: `function searchvalue (list, keyWord) {
  if (keyWord !== '') {
    var reg = new RegExp(keyWord)
    var arr = []
    for (var i = 0; i < list.length; i++) {
      if (reg.test(list[i].name) || reg.test(list[i].videoCode)) {
        arr.push(list[i])
      }
    }
    return arr
  } else {
    return []
  }
}`
    }, {
        name: '大屏[3840*1920]屏幕适配方案',
        html: `//在index.html中加入  将px转换为1rem=19.2px
 function fnResize () {
 const deviceWidth = document.documentElement.clientWidth || window.innerWidth
 const deviceheight = document.documentElement.clientHeight || window.innerHeight
 if (deviceWidth >= 3820 && deviceWidth < 3890) {
     document.documentElement.style.fontSize = (deviceheight / 56.25) + 'px'
 } else if (deviceWidth < 3840 && deviceWidth > 1920) {
     document.documentElement.style.fontSize = (deviceWidth / 150) + 'px'
 } else if (1920 >= deviceWidth) {
     document.documentElement.style.fontSize = (deviceheight / 56.22) + 'px'
 }
}
window.onresize = function () {
    fnResize()
}
if (document.createEvent) {
    let event = document.createEvent('HTMLEvents')
    event.initEvent('resize', true, true)
    window.dispatchEvent(event)
} else if (document.createEventObject) {
    window.fireEvent('onresize')
}`
    }, {
        name: '实现一个防抖Hook',
        html:
            `import { useEffect } from "react"; 

export const useDebounce = <V>(value: V, delay?: number) => {
  const [debouncedValue, setDebouncedValue] = useState(value);

  useEffect(() => {
    // 每次在value变化以后，设置一个定时器
    const timeout = setTimeout(() => setDebouncedValue(value), delay);
    // 每次在上一个useEffect处理完以后再运行
    return () => clearTimeout(timeout);
  }, [value, delay]);

  return debouncedValue;
};`
    },
    {
        name: "数组方法",
        html: `
const list=[{name:'张三',value:3},{name:'李四',value:1},{name:'小胖',value:0}]

// push()，从后面添加元素，返回值为添加完元素后的数组长度
list.push({name:'岳小胖',value:4}) //[{name:'张三',value:3},{name:'李四',value:1},{name:'小胖',value:0},{name:'岳小胖',value:4}]

// pop()，从后面删除元素，只能删除一个，返回值为删除的元素
list.pop() //{name:'小胖',value:0}

// shift()，从前面删除元素，只能删除一个，返回值为删除的元素
list.shift() //{name:'张三',value:3}

// unshift()，从前面添加元素，返回值是添加完元素后的数组长度
list.unshift({name:'岳小胖',value:4}) // 4 当前数组长度

// splice(i, l)，删除从i开始的，长度为l的元素，返回值是删除的元素
list.splice(0,1) //[{name:'张三',value:3}]

// slice(start, end)，切去索引值start到end的数组，不包含end，返回值是切出来的数组
list.slice(1,2) //[{"name": "李四","value": 1}]

// substr(),从起始索引号提取字符串中指定书目的字符
const str = "nihaoya wohenhao dajiahao"
const str3 = str.substr(3,19); 字符串中空格不占位置，从3开始，到19结束
console.log(str3); // aoya wohenhao dajia

// concat()，连接两个数组，返回值为连接后的新数组
let arr1=[1,2],arr2=[3]
const arr=arr1.concat(arr2) // [1,2,3]

// sort()，将数组进行排序,返回值是排好的数组，默认是按照最左边的数字进行排序，不是按照数字大小排序的
let newList=list.sort(function (a,b){return a.value-b.value})
console.log(newList) //[{"name": "小胖","value": 0 },{"name": "李四","value": 1},{"name": "张三","value": 3}]

// reverse()，反转数组，返回值是反转后的数组
list.reverse() //

// split()，将字符串转换为数组
let name="1,2,3,4"
name.split(',') //['1', '2', '3', '4']

// join(),将数组的元素组成一个字符串
let name=[1,2,3]
name.join(',') // "1,2,3"

// indexOf(),从数组(字符串)的开头向后查找，接受两个参数，要查找的项和查找起点的位置索引 没用查到则返回-1 
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple") //2 

// forEach()，对数组的每个元素执行一次提供的函数
list.forEach(function(item)){
     console.log(item)
}

// map()，对数组的每一项运行给定的函数，返回没戏函数调用的结果组成的数组
var arr = [1, 4, 9, 16];
const map1 = arr.map(x => x * 2); //对数组的每项*2
console.log(map1); // 2 8 18 32

// for in方法，遍历数组
for (var i = 0; i < list.length; i++){
    console.log(list[i]); 
}

// filter()，过滤数组，返回一个满足要求的数组
let newList =list.filter(item => item.value>1) //[{name: '张三', value: 3}]

every(),是所有函数的每个回调都返回true的时候才会返回true，当遇到false的时候终止执行，返回false 全真则真

some(),是存在有一个函数返回true的时候终止执行并返回true，否则返回false 一真则真

find(),方法返回数组中符合测试函数条件的第一个元素。否则返回undefined

reduce(),接收一个函数作为累加器（accumulator），数组中的每个值（从左到右）开始缩减，最终为一个值
var total = [0,1,2,3,4].reduce((a, b)=>a + b); //10
                                上一次的值，当前值，当前值的索引，数组
[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array){
 return previousValue + currentValue;
});


`
    },
    {
        name: '函数防抖 (只执行最后一次点击)',
        html:`Debounce = (fn, t) => {
    let delay = t || 500;
    let timer;
    return function () {
        let args = arguments;
        if(timer){
            clearTimeout(timer);
        }
        timer = setTimeout(() => {
            timer = null;
            fn.apply(this, args);
        }, delay);
    }
};
`
    }, {
        name: '函数节流（一段时间内只执行一次）',
        html:`Throttle = (fn, t) => {
    let last;
    let timer;
    let interval = t || 500;
    return function () {
        let args = arguments;
        let now = +new Date();
        if (last && now - last < interval) {
            clearTimeout(timer);
            timer = setTimeout(() => {
                last = now;
                fn.apply(this, args);
            }, interval);
        } else {
            last = now;
            fn.apply(this, args);
        }
    }
};
`
    }
]
